package cn.ml.duoXianCheng.demos;

import java.io.IOException;

public class DuoXianChengDemo {
    public static void main(String[] args) throws IOException {
        /*
        如何创建和启动线程
        1.继承 Thread类 创建对象 调用start
        class A extends Thread{
            run(){}
        }
        new Thread().start();

        2.实现 Runnable 创建对象 以其为参数创建Thread对象 调用start
        class B implements Runnable{
            run()
        }
        new Thread(new B()).start();

        start属于Thread中定义的方法
        线程优先级(1,10)
        Thread.MAX_PRIORITY( =10)
        Thread.MIN_PRIORITY( =1)
        Thread.NORM_PRIORITY( =5)
        new Thread().setPriority(n);  （1 <= n >=10）

        Thread.sleep(ms)        //阻塞  不释放锁
        synchronized（obj）     //锁  被它所定的代码块串行（obj排队）  代码块中代码执行完自动释放锁

        Object.wait()           //阻塞  释放锁
        Object.notify()         //唤醒一个 (阻塞线程的第一个  obj中的第一个)
        Object.notifyAll()      //唤醒所有
        当方法wait()被执行后，锁自动被释放，但执行完notify()方法后，锁不会自动释放。必须执行完notify()方法所在的synchronized代码块后才释放。

        如果一个线程调用了某个对象的wait方法，那么该线程进入到该对象的等待池中(并且已经将锁释放)，如果未来的某一时刻，另外一个线程调用
        了相同对象的notify方法或者notifyAll方法，那么该等待池中的线程就会被唤起，然后进入到对象的锁池里面去获得该对象的锁，如果获得锁成功后，
        那么该线程就会沿着wait方法之后的路径继续执行。注意是沿着wait方法之后

        Thread.setDaemon(x)     //设置线程为守护线程
        Thread.isDaemon()       //判断是否为守护线程
        Thread.join()           //阻塞 阻塞调用者，被调用的线程加入执行，直到被调用结束，调用者才恢复阻塞
        Thread.yield()         //礼让   一个线程礼让他获得CPU的机会就少
         */

        //守护线程Demo
        /*Thread t = new Thread(){
            @Override
            public void run() {
                for(int i=0;i<30;i++){
                    System.out.println(i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.setDaemon(true);   //设置 t 为守护线程

        t.start();
        System.in.read();
        System.out.println("main over......");*/


        //Thread.jion()Demo
        /*Thread t1 = new Thread(){
            @Override
            public void run() {
                for(int i=10;i>0;i--){
                    System.out.println(i+"--t1");
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for(int i=0;i<30;i++){
                    System.out.println(i+"--t2");
                    if(i == 5){
                        try {
                            t1.join();    //当i=5 ti加入进来,则先进行t1，直到t1执行完
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t2.start();*/




    }

}
